/*
* Copyright (C) 2006, 2007 Dennis Hunziker, Ueli Kistler
* Copyright (C) 2007 Reto Schuettel, Robin Stocker
*
* IFS Institute for Software, HSR Rapperswil, Switzerland
*
*/
package org.python.pydev.refactoring.ast.visitors.context;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import org.python.pydev.core.structure.FastStack;
import org.python.pydev.parser.jython.SimpleNode;
import org.python.pydev.parser.jython.ast.ClassDef;
import org.python.pydev.parser.jython.ast.FunctionDef;
import org.python.pydev.parser.jython.ast.VisitorBase;
import org.python.pydev.parser.jython.ast.factory.NodeHelper;
import org.python.pydev.refactoring.ast.adapters.AbstractNodeAdapter;
import org.python.pydev.refactoring.ast.adapters.AbstractScopeNode;
import org.python.pydev.refactoring.ast.adapters.ClassDefAdapter;
import org.python.pydev.refactoring.ast.adapters.FunctionDefAdapter;
import org.python.pydev.refactoring.ast.adapters.ModuleAdapter;
import org.python.pydev.refactoring.ast.adapters.SimpleAdapter;
public abstract class AbstractContextVisitor<T> extends VisitorBase {
protected NodeHelper nodeHelper;
protected List<T> nodes;
protected final FastStack<AbstractScopeNode<?>> parents;
protected final FastStack<SimpleNode> stack;
protected ModuleAdapter moduleAdapter;
public AbstractContextVisitor(ModuleAdapter module, AbstractNodeAdapter<? extends SimpleNode> parent) {
super();
assert (module != null);
this.moduleAdapter = module;
nodeHelper = new NodeHelper(module.getAdapterPrefs());
stack = new FastStack<SimpleNode>(10);
parents = new FastStack<AbstractScopeNode<?>>(10);
parents.push(moduleAdapter);
stack.push(module.getASTNode());
nodes = new ArrayList<T>();
}
private void add(T node) {
nodes.add(node);
}
protected void after() {
stack.pop();
}
protected AbstractNodeAdapter<? extends SimpleNode> before(SimpleNode node) {
AbstractNodeAdapter<? extends SimpleNode> context = createContext(node);
stack.push(node);
return context;
}
private AbstractNodeAdapter<? extends SimpleNode> create(SimpleNode node) {
AbstractScopeNode<?> parent = parents.peek();
if (nodeHelper.isClassDef(node)) {
return new ClassDefAdapter(moduleAdapter, parent, (ClassDef) node, moduleAdapter.getAdapterPrefs());
} else if (nodeHelper.isFunctionDef(node)) {
return new FunctionDefAdapter(moduleAdapter, parent, (FunctionDef) node, moduleAdapter.getAdapterPrefs());
} else {
return new SimpleAdapter(moduleAdapter, parent, node, moduleAdapter.getAdapterPrefs());
}
}
protected abstract T createAdapter(AbstractScopeNode<?> parent, SimpleNode node);
protected AbstractNodeAdapter<? extends SimpleNode> createContext(SimpleNode node) {
if (nodeHelper.isModule(node)) {
assert (node == moduleAdapter.getASTNode());
return moduleAdapter;
}
return create(node);
}
public List<T> getAll() {
return nodes;
}
protected boolean isInClassDef() {
for (SimpleNode node : stack) {
if (nodeHelper.isClassDef(node)) {
return true;
}
}
return false;
}
protected boolean isInFunctionDef() {
for (SimpleNode node : stack) {
if (nodeHelper.isFunctionDef(node)) {
return true;
}
}
return false;
}
protected boolean isParentClassDecl() {
return nodeHelper.isClassDef(parents.peek().getASTNode());
}
public Iterator<T> iterator() {
return nodes.iterator();
}
protected void registerInContext(SimpleNode node) {
T context = createAdapter(parents.peek(), node);
add(context);
}
protected void trackContext(SimpleNode node) throws Exception {
AbstractNodeAdapter<? extends SimpleNode> context = before(node);
pushParent(context);
traverse(node);
parents.pop();
after();
}
protected void updateASTContext(SimpleNode node) throws Exception {
before(node);
traverse(node);
after();
}
public void traverse(FunctionDef node) throws Exception {
if (node.decs != null) {
visit(node.decs);
}
visit(node.name);
visit(node.args);
visit(node.body);
}
@Override
public void traverse(SimpleNode node) throws Exception {
if (nodeHelper.isFunctionDef(node)) {
traverse((FunctionDef) node);
} else {
node.traverse(this);
}
}
@Override
protected Object unhandled_node(SimpleNode node) throws Exception {
return null;
}
public void visit(SimpleNode node) throws Exception {
if (node == null) {
return;
}
node.accept(this);
}
protected void visit(SimpleNode[] body) throws Exception {
if (body == null) {
return;
}
for (SimpleNode node : body) {
visit(node);
}
}
public Object visitClassDef(ClassDef node) throws Exception {
trackContext(node);
return null;
}
@Override
public Object visitFunctionDef(FunctionDef node) throws Exception {
AbstractNodeAdapter<? extends SimpleNode> context = before(node);
pushParent(context);
traverse(node);
parents.pop();
after();
return null;
}
protected void pushParent(AbstractNodeAdapter<? extends SimpleNode> context) {
if (context instanceof AbstractScopeNode<?>) {
parents.push((AbstractScopeNode<?>) context);
}
}
}